{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "98059d3f-e2af-4b55-9889-023989e8dc4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import pandas as pd\n",
    "import re\n",
    "from sklearn.model_selection import train_test_split\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from transformers import BertTokenizer, BertForSequenceClassification, AdamW\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e70e26bf-cf23-4c34-98de-bf3e634db833",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 检查设备\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54e598eb-39a9-49b6-b46e-0ea1deade620",
   "metadata": {},
   "source": [
    "### 数据预处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cebd3cd9-6cb3-472c-82a1-c3b9e2cd19b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据数量508110\n",
      "                                                  content  stars  label\n",
      "327336                                             万物总有季节      3      0\n",
      "330081  很日本的电影一部。换做一年之前。我还知道幸存者。我还不知道真人秀型“人性测试”游戏的话，也许...      3      0\n",
      "435485                                                 聊斋      3      0\n",
      "69579                      james horner的音乐太好听了，听哭。仿佛想到童年。      5      1\n",
      "451014  这是个什么故事啊，为什么大雄和胖妹在一起就不幸福，非要和颜值高的静香在一起才叫幸福？这三观也...      3      0\n"
     ]
    }
   ],
   "source": [
    "# 读取数据集\n",
    "data_path = '../datasets/chinese_movie_reviews/chinese_movie_reviews_datasets.jsonl'\n",
    "df = pd.read_json(data_path, orient='records', lines=True)\n",
    "print(f'数据数量{len(df)}')\n",
    "print(df.sample(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "67205ffc-dde4-45ab-9259-544c835af2c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                                  content  stars  label\n",
      "325396                                       一个非常康斯太勃尔的场景      3      0\n",
      "382322      日版麦克白看那充满欲念的古城遗址游魂野鬼仍然徘徊不散人的欲望如惨烈的战场不论古今都永不变改      3      0\n",
      "108163                         印度科幻片地狱级难度考试胜率百万分之一印度小镇做题家      5      1\n",
      "27251   莫里康内神配乐首用电吉他风铃与怀表内在音乐转外在以渐进式特写和渐次间断性闪回强化悬念揭示人物...      5      1\n",
      "189784                                 向前进向前进战士的责任重妇女的冤仇深      4      1\n"
     ]
    }
   ],
   "source": [
    "# 移除数字\n",
    "def remove_digit(text):\n",
    "     return re.sub(r'\\d+', '', text)\n",
    "\n",
    "# 移除非汉字字符\n",
    "def remove_non_chinese(text):\n",
    "    return re.sub(r\"[^\\u4e00-\\u9fa5]\", \"\", text)\n",
    "\n",
    "# 应用预处理\n",
    "def process_row(text):\n",
    "    text = remove_digit(text)\n",
    "    text = remove_non_chinese(text)  # 只保留汉字字符\n",
    "    return text\n",
    "\n",
    "df[\"content\"] = df[\"content\"].apply(process_row)\n",
    "print(df.sample(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "16eda3cc-94e3-4341-b834-ca9894bcb4a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 构建文本数据集类\n",
    "class TextDataset(Dataset):\n",
    "    def __init__(self, texts, labels, tokenizer, max_length=128):\n",
    "        self.texts = texts\n",
    "        self.labels = labels\n",
    "        self.tokenizer = tokenizer\n",
    "        self.max_length = max_length\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.labels)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        text = self.texts[idx]\n",
    "        label = self.labels[idx]\n",
    "        encoding = self.tokenizer.encode_plus(\n",
    "            text,\n",
    "            add_special_tokens=True,\n",
    "            max_length=self.max_length,\n",
    "            return_token_type_ids=False,\n",
    "            padding='max_length',\n",
    "            truncation=True,\n",
    "            return_attention_mask=True,\n",
    "            return_tensors='pt',\n",
    "        )\n",
    "        return {\n",
    "            'input_ids': encoding['input_ids'].flatten(),\n",
    "            'attention_mask': encoding['attention_mask'].flatten(),\n",
    "            'labels': torch.tensor(label, dtype=torch.long)\n",
    "        }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6380ae67-d513-4f7e-83b2-bf3d204f8b40",
   "metadata": {},
   "source": [
    "这里通过transformers加载预训练Bert模型，   \n",
    "如果`BertTokenizer.from_pretrained('bert-base-chinese')`报错的话，  \n",
    "从[bert-base-chinese](https://huggingface.co/google-bert/bert-base-chinese/tree/main)手动下载    `vocab.txt`,`tokenizer_config.json`,`pytorch_model.bin`,`config.json`文件\n",
    "并保存到`models/3_Chinese_Movie_review_Text_Classification/bert-base-chinese`文件夹，  \n",
    "然后使用`BertTokenizer.from_pretrained(path)`从本地加载模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b1f92178-6982-42ea-89d3-702c836b9176",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 分割数据集\n",
    "X = df['content'].values\n",
    "y = df['label'].values\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42, stratify=y)\n",
    "\n",
    "# 使用 BERT 的 Tokenizer 对文本进行编码，生成input_ids和attention_mask\n",
    "# tokenizer = BertTokenizer.from_pretrained('bert-base-chinese') # 可能会报错\n",
    "# 手动下载后从本地加载\n",
    "tokenizer = BertTokenizer.from_pretrained('../models/3_Chinese_Movie_review_Text_Classification/bert-base-chinese')\n",
    "\n",
    "train_dataset = TextDataset(X_train, y_train, tokenizer)\n",
    "test_dataset = TextDataset(X_test, y_test, tokenizer)\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1df96f68-0fcf-4212-b4ce-c92006d84584",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集大小: 457299\n",
      "测试集大小: 50811\n",
      "训练集标签分布: Counter({1: 228650, 0: 228649})\n",
      "测试集标签分布: Counter({0: 25406, 1: 25405})\n"
     ]
    }
   ],
   "source": [
    "# 查看训练集和测试集的大小\n",
    "print(f\"训练集大小: {len(train_dataset)}\")\n",
    "print(f\"测试集大小: {len(test_dataset)}\")\n",
    "\n",
    "# 查看训练集和测试集的标签分布\n",
    "from collections import Counter\n",
    "\n",
    "train_labels_counter = Counter(y_train)\n",
    "test_labels_counter = Counter(y_test)\n",
    "print(f\"训练集标签分布: {train_labels_counter}\")\n",
    "print(f\"测试集标签分布: {test_labels_counter}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18978d49-5477-4abf-a19c-117033e80a8d",
   "metadata": {},
   "source": [
    "### 构建模型(加载预训练 Bert)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3f171a9d-d091-4c22-8583-de4ae6d225a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at ../models/3_Chinese_Movie_review_Text_Classification/bert-base-chinese and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n",
      "D:\\develop\\anaconda\\envs\\pytorch\\lib\\site-packages\\transformers\\optimization.py:591: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\n可能出现警告, 这个警告信息是正常的，不需要担心！\\n它表示 BertForSequenceClassification 模型的一部分权重（特别是分类头的权重）是随机初始化的，而不是从预训练模型中加载的。\\n这是因为我们在加载模型时指定了 num_labels=2，即模型需要适应一个新的二分类任务。\\n'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 加载BERT模型\n",
    "\n",
    "# 使用BertForSequenceClassification进行分类任务，num_labels=2表示二分类\n",
    "# model = BertForSequenceClassification.from_pretrained('bert-base-chinese', num_labels=2).to(device) # 可能会报错\n",
    "# 手动下载后从本地加载\n",
    "model = BertForSequenceClassification.from_pretrained('../models/3_Chinese_Movie_review_Text_Classification/bert-base-chinese', num_labels=2).to(device)\n",
    "optimizer = AdamW(model.parameters(), lr=2e-5)\n",
    "loss_fn = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "\"\"\"\n",
    "可能出现警告, 这个警告信息是正常的，不需要担心！\n",
    "它表示 BertForSequenceClassification 模型的一部分权重（特别是分类头的权重）是随机初始化的，而不是从预训练模型中加载的。\n",
    "这是因为我们在加载模型时指定了 num_labels=2，即模型需要适应一个新的二分类任务。\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "26db35e9-1f85-4af9-9101-86df84d7c253",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BertForSequenceClassification(\n",
      "  (bert): BertModel(\n",
      "    (embeddings): BertEmbeddings(\n",
      "      (word_embeddings): Embedding(21128, 768, padding_idx=0)\n",
      "      (position_embeddings): Embedding(512, 768)\n",
      "      (token_type_embeddings): Embedding(2, 768)\n",
      "      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
      "      (dropout): Dropout(p=0.1, inplace=False)\n",
      "    )\n",
      "    (encoder): BertEncoder(\n",
      "      (layer): ModuleList(\n",
      "        (0-11): 12 x BertLayer(\n",
      "          (attention): BertAttention(\n",
      "            (self): BertSdpaSelfAttention(\n",
      "              (query): Linear(in_features=768, out_features=768, bias=True)\n",
      "              (key): Linear(in_features=768, out_features=768, bias=True)\n",
      "              (value): Linear(in_features=768, out_features=768, bias=True)\n",
      "              (dropout): Dropout(p=0.1, inplace=False)\n",
      "            )\n",
      "            (output): BertSelfOutput(\n",
      "              (dense): Linear(in_features=768, out_features=768, bias=True)\n",
      "              (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
      "              (dropout): Dropout(p=0.1, inplace=False)\n",
      "            )\n",
      "          )\n",
      "          (intermediate): BertIntermediate(\n",
      "            (dense): Linear(in_features=768, out_features=3072, bias=True)\n",
      "            (intermediate_act_fn): GELUActivation()\n",
      "          )\n",
      "          (output): BertOutput(\n",
      "            (dense): Linear(in_features=3072, out_features=768, bias=True)\n",
      "            (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n",
      "            (dropout): Dropout(p=0.1, inplace=False)\n",
      "          )\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (pooler): BertPooler(\n",
      "      (dense): Linear(in_features=768, out_features=768, bias=True)\n",
      "      (activation): Tanh()\n",
      "    )\n",
      "  )\n",
      "  (dropout): Dropout(p=0.1, inplace=False)\n",
      "  (classifier): Linear(in_features=768, out_features=2, bias=True)\n",
      ")\n",
      "模型总参数数量: 102,269,186\n",
      "模型可训练参数数量: 102,269,186\n"
     ]
    }
   ],
   "source": [
    "# 查看模型结构\n",
    "# 打印模型参数总数和可训练参数总数\n",
    "def count_parameters(model):\n",
    "    total_params = sum(p.numel() for p in model.parameters())  # 所有参数数量\n",
    "    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)  # 需要训练的参数数量\n",
    "    print(f\"模型总参数数量: {total_params:,}\")\n",
    "    print(f\"模型可训练参数数量: {trainable_params:,}\")\n",
    "\n",
    "print(model)\n",
    "count_parameters(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31558679-4dea-4e47-93b3-8d9fce6e4f9e",
   "metadata": {},
   "source": [
    "### 模型训练与评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4fcbf913-5e9c-4981-8ac0-5c26b0081474",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练函数\n",
    "def train(dataloader, model, loss_fn, optimizer):\n",
    "    model.train()\n",
    "    running_loss = 0.0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "\n",
    "    progress_bar = tqdm(dataloader, desc=\"Training\", leave=False)\n",
    "    for batch in progress_bar:\n",
    "        input_ids = batch['input_ids'].to(device)\n",
    "        attention_mask = batch['attention_mask'].to(device)\n",
    "        labels = batch['labels'].to(device)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(input_ids=input_ids, attention_mask=attention_mask, labels=labels)\n",
    "        loss = outputs.loss\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        running_loss += loss.item()\n",
    "        _, predicted = torch.max(outputs.logits, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "\n",
    "        progress_bar.set_postfix(loss=loss.item())\n",
    "    \n",
    "    accuracy = 100 * correct / total\n",
    "    avg_loss = running_loss / len(dataloader)\n",
    "    return avg_loss, accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f130e30d-37e7-4836-b6d9-9cf8aa082874",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 测试函数\n",
    "def evaluate(dataloader, model, loss_fn):\n",
    "    model.eval()\n",
    "    running_loss = 0.0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        progress_bar = tqdm(dataloader, desc=\"Evaluating\", leave=False)\n",
    "        for batch in progress_bar:\n",
    "            input_ids = batch['input_ids'].to(device)\n",
    "            attention_mask = batch['attention_mask'].to(device)\n",
    "            labels = batch['labels'].to(device)\n",
    "\n",
    "            outputs = model(input_ids=input_ids, attention_mask=attention_mask, labels=labels)\n",
    "            loss = outputs.loss\n",
    "\n",
    "            running_loss += loss.item()\n",
    "            _, predicted = torch.max(outputs.logits, 1)\n",
    "            total += labels.size(0)\n",
    "            correct += (predicted == labels).sum().item()\n",
    "\n",
    "            progress_bar.set_postfix(loss=loss.item())\n",
    "    \n",
    "    accuracy = 100 * correct / total\n",
    "    avg_loss = running_loss / len(dataloader)\n",
    "    return avg_loss, accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "52762d06-d54d-408f-8cc0-75ec61fb4b77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training:   0%|                                                                              | 0/14291 [00:00<?, ?it/s]D:\\develop\\anaconda\\envs\\pytorch\\lib\\site-packages\\transformers\\models\\bert\\modeling_bert.py:440: UserWarning: 1Torch was not compiled with flash attention. (Triggered internally at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\native\\transformers\\cuda\\sdp_utils.cpp:555.)\n",
      "  attn_output = torch.nn.functional.scaled_dot_product_attention(\n",
      "                                                                                                                       \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1, Train_acc:70.0%, Train_loss:0.560, Test_acc:72.0%，Test_loss:0.539\n",
      "Epoch 2/5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 2, Train_acc:73.5%, Train_loss:0.514, Test_acc:72.3%，Test_loss:0.539\n",
      "Epoch 3/5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 3, Train_acc:76.3%, Train_loss:0.472, Test_acc:72.1%，Test_loss:0.556\n",
      "Epoch 4/5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 4, Train_acc:79.4%, Train_loss:0.425, Test_acc:71.3%，Test_loss:0.592\n",
      "Epoch 5/5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 5, Train_acc:82.5%, Train_loss:0.374, Test_acc:71.1%，Test_loss:0.630\n",
      "训练完成!\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "# 开始训练\n",
    "num_epochs = 5\n",
    "\n",
    "train_loss = []\n",
    "train_acc  = []\n",
    "test_loss  = []\n",
    "test_acc   = []\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    print(f\"Epoch {epoch+1}/{num_epochs}\")\n",
    "    \n",
    "    epoch_train_loss, epoch_train_acc = train(train_loader, model, loss_fn, optimizer)\n",
    "    epoch_test_loss, epoch_test_acc = evaluate(test_loader, model, loss_fn)\n",
    "\n",
    "    train_acc.append(epoch_train_acc)\n",
    "    train_loss.append(epoch_train_loss)\n",
    "    test_acc.append(epoch_test_acc)\n",
    "    test_loss.append(epoch_test_loss)\n",
    "\n",
    "    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}')\n",
    "    print(template.format(epoch+1, epoch_train_acc, epoch_train_loss, epoch_test_acc, epoch_test_loss))\n",
    "\n",
    "print(\"训练完成!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1be353c3-b994-4cbf-ab4e-5868f7f2b58f",
   "metadata": {},
   "source": [
    "### 结果可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5593d2ad-3111-4310-a546-32bbfe7be094",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x300 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "epochs_range = range(num_epochs)\n",
    "\n",
    "plt.figure(figsize=(12, 3))\n",
    "plt.subplot(1, 2, 1)\n",
    "\n",
    "plt.plot(epochs_range, train_acc, label='Training Accuracy')\n",
    "plt.plot(epochs_range, test_acc, label='Test Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "plt.title('Training and Validation Accuracy')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(epochs_range, train_loss, label='Training Loss')\n",
    "plt.plot(epochs_range, test_loss, label='Test Loss')\n",
    "plt.legend(loc='upper right')\n",
    "plt.title('Training and Validation Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52a76a05-8079-4ca5-9323-edf4fe783d81",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
